Een leeg ASP.NET Core 3.x project maken

Stappenplan

Je kan een ASP.NET Core applicatie vanaf de command-line interface (CLI) of in Visual Studio. In deze les leren we hoe dat doet vanaf de CLI.

1. Zorg ervoor dat je je werk op je lokale computer gesynchroniseerd hebt met BitBucket:
   1. Lokaal naar remotel:
      1. ga naar de map Programmeren3;
      2. git status
      3. git add --all
      4. git commit -m "Tot en met les 9"
      5. indien nodig: git remote add origin https://JosephInghelbrecht@bitbucket.org/JosephInghelbrecht/programmeren-3.git
      6. git pusch -u origin master
   2. remote naar lokaal:
      1. indien nodig: git remote add origin https://JosephInghelbrecht@bitbucket.org/JosephInghelbrecht/programmeren-3.git
      2. git pull origin master
2. Video
   ;
3. We gaan er vanuit dat je .NET Core (de laatste stabiele versie) al geïnstalleerd hebt ( .NET Core 3.1 SDK or later ).
4. Ga naar de map die als workspace voor deze module gebruikt:
   cd C:\Users\jefin\OneDrive\AP\Programmeren3
5. Je hebt een map met de naam dotnetcore in je workspace (bv. lokale Programmeren3 map) gemaakt. Als je die map nog niet hebt gemaakt typ dat in de terminal:
   md dotnetcore

   

6. Ga naar de map dotnetcore:
   cd dotnetcore
7. Creëer een map in de dotnetcore map van je workspace met de naam aspdotnet:
   md aspdotnet
8. Om naar de map te gaan typ je in het Terminal venster:
   cd aspdotnet
9. Met het commando dotnet kan je nieuwe .NET Core-projecten creëren. Het commando dotnet new zonder extra argumenten toont een lijst met de beschikbare project sjablonen (templates). In het Terminal venster typ je:
   dotnet new

   

10. We maken een leeg ASP.NET Core project in de map aspdotnet door het uitvoeren van dotnet new web.
11. Typ ls om de nieuw gemaakte bestanden en mappen in de aspdotnet map te tonen:

    

12. Trust the HTTPS development certificate
    Op Windows en macOS:

    dotnet dev-certs https --trust

    Meer informatie op Trust the ASP.NET Core HTTPS development certificate

    

13. Zodra het project is aangemaakt, moet je het kunnen uitvoeren met de instructie dotnet run. In eerdere versies van .NET Core (1) was het nodig om eerst de dotnet restore instructie uit te voeren om de nodige NuGet-pakketten te installeren. Maar vanaf .NET Core 2.0, wordt het restore commando nu automatisch uitgevoerd door CLI commando's die er afhankelijk van zijn. Open de website, die op basis van de sjabloon is gemaakt, door dotnet run uit te voeren en te navigeren naar de URL waarnaar de app luistert. In Windows is dat waarschijnlijk http://localhost:5000, de default url die aan je app wordt toegekend.

    

14. Voer de instructie dotnet run uit en open de pagina http://localhost:5000 of https://localhost:5001:

    

15. Hoe komt die Hello World in het browservenster?
    Als je een ASP.NET Core app maakt maak je eigenlijk een console app die je op Windows, Linux of IOS kan runnen. Er worden twee bestanden automatisch aangemaakt:
    1. In Startup.cs staat wat de app moet doen bij het opstarten

       // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
       
       public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
       {
           if (env.IsDevelopment())
           {
               app.UseDeveloperExceptionPage();
           }
           app.UseRouting();
           app.UseEndpoints(endpoints =>
           {
               endpoints.MapGet("/", async context =>
               {
                   await context.Response.WriteAsync("Hello World!");
               });
           });
       }

       De app configureert de applicatie zodanig dat de uitzonderingspagina geserveerd wordt in geval van problemen. Dit wordt alleen weergegeven als de app wordt uitgevoerd in de ontwikkelmodus. Als de app naar de productie modus overschakelt wanneer deze in een live omgeving wordt ingezet, wordt dit niet uitgevoerd. Ten slotte moeten we beslissen wat er daadwerkelijk moet gebeuren wanneer de app wordt uitgevoerd. Dat doet de app.Run-code. In dit geval schrijft het gewoon "Hello World!" rechtstreeks naar de webrespons stream.
    2. In Program.cs configureer je de dependencies en de middleware van de app:

       public class Program
       {
           public static void Main(string[] args)
           {
               CreateHostBuilder(args).Build().Run();
           }
           public static IHostBuilder CreateHostBuilder(string[] args) =>
               Host.CreateDefaultBuilder(args)
                   .ConfigureWebHostDefaults(webBuilder =>
                   {
                       webBuilder.UseStartup<Startup>();
                  });
       
       }

       Middleware verwijst naar de verschillende 'dingen' die hier worden geconfigureerd, zoals het gebruik van Kestrel (cross-platform web server) die impliciet wordt opgestart. Zij zijn de bouwstenen van je webapp en worden uitgevoerd als onderdeel van de pipeline van je applicatie. Middleware is handig voor dingen zoals authenticatie waarbij je elk verzoek om beveiligde inhoud door een verificatiestadium laat gaan voordat de werkelijke inhoud wordt weergegeven.
       Program.cs bevat het startpunt van de applicatie. ASP.NET Core-apps zijn net als console-applicaties en hebben een Main-methode die uitgevoerd wordt de app wordt geöpend. De belangrijkste methoden zijn vrij eenvoudig. Ze maken een IWebHost-object en starten die met Run op.
16. Tenslotte bekijken we het .csproj bestand.
    In onze app is dat het projectbestand met de naam aspdotnet.csproj:

    <Project Sdk="Microsoft.NET.Sdk.Web">
      <PropertyGroup>
        <TargetFramework>netcoreapp3.1</TargetFramework>
      </PropertyGroup>
    </Project>

    Dit bestand vertelt MSBuild hoe het project wordt gebouwd - van welke pakketten het afhankelijk is, welke versie van .NET Core te targeten, enzovoort. In vorige versies van .NET Core was dit projectbestand veel groter. .NET Core 2.0 heeft veel moeite gestoken in het korter, eenvoudiger en leesbaarder maken van .csproj-bestanden. Bronbestanden moeten niet langer expliciet moeten worden vermeld. De .NET Core SDK compileert automatisch alle .cs-bestanden die in de map van het projectbestand staan of in een directory onder de .csproj-directory. Op dezelfde manier zullen eventuele .resx-bestanden worden ingebed als bronnen. Als je liever niet alle .cs-bestanden wilt compileren, kan je ze uit de Compile ItemGroup verwijderen of de standaard compile-items volledig uitschakelen door de eigenschap EnableDefaultCompileItems op false te zetten.

    Het element <PackageReference> in het midden van het .csproj-bestand verwijst naar een NuGet-pakket waarvan het project afhankelijk is. Vanaf ASP.NET Core 2.0 dat u nu standaard slechts één meta-pakket (Microsoft.AspNetCore.All). Dit pakket bevat alle andere Microsoft.AspNetCore-pakketten in één korte referentie en maakt ASP.NET Core 2.0 projectbestanden veel kleiner dan projectbestanden van vroegere versies. Extra afhankelijkheden (dependancies) van NuGet kunnen worden toegevoegd door meer <PackageReference> -elementen toe te voegen, door gebruik te maken van de gebruikersinterface van Visual Studio NuGet Package, of met de .NET CLI dotnet add opdracht.

17. Synchroniseer BitBucket met je lokale computer:
    1. ga naar de root van je workspace: bv. cd C:\Users\jefin\OneDrive\AP\Programmeren3
       1. git status
       2. git add --all
       3. git commit -m "aspdotnet project gecreëerd met de CLI"
       4. indien nodig: git remote add origin https://JosephInghelbrecht@bitbucket.org/JosephInghelbrecht/programmeren-3.git
       5. git pusch -u origin master

Bronnen

1. Microsoft, Tutorial: Get started with ASP.NET Core, 01/07/2020